package com.palmplaystore.bigdata.util;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.regex.Pattern;

public abstract class StringUtil {

    public static final String   ALL_MOBILE         = "^[1](([3]|[4]|[5]|[7]|[8])[0-9]{1})[0-9]{8}$";

    /**
     * 返回字符串的值，如果字符串为空则返回默认值
     * 
     * @param src 字符串
     * @param defaultValue 默认值
     * @return
     */
    public static final String nvl(String src, String defaultValue) {
        if (src != null && src.length() > 0) {
            return src;
        } else {
            return defaultValue;
        }
    }

    public static final String nvl(String src) {
        return nvl(src, "");
    }

    /**
     * 得到当前日期/时间字符串
     * 
     * @return 返回日期/时间字符串
     */
    public static String getNowDateTimeString(String type) {
        Date date = new Date();
        SimpleDateFormat formattxt = new SimpleDateFormat(type);
        return formattxt.format(date);
    }

    /**
     * 判断给入的字符串是否为空,null、""、" "都表示空字符串
     * 
     * @param str 待判定的字符串
     * @return 空符串返回true，否则返回false
     */
    public static boolean isEmpty(String str) {
        if (null == str || "".equals(str.trim()) || "null".equals(str.trim())) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 生成签名
     * 
     * @return
     */
    public static String generateAppKey() {
        String uuid = UUID.randomUUID().toString().replaceAll("-", "").trim();
        return uuid;
    }

    /**
     * 生成uuid
     * 
     * @return
     */
    public static String getUUID() {
        return UUID.randomUUID().toString();
    }

    /**
     * 从给定的内容content中获取给定的start字符串到end字符串的所有内容，其中start和end的配对可以是多处，最终以List结果返回。<br>
     * 如给定的内容content为：adfadfsdfasBBttttCCxaafdsfdsBBddadfasfsfdCCxxxx，<br>
     * start为:BB<br>
     * end为：CC<br>
     * 则返回的list结果包括两条记录：tttt 和 ddadfasfsfd.<br>
     * 在获取时，end字符串所处的位置一定要大于start所处的位置，否则不以处理，默认来配对不成功，跳出处理的循环。
     * 
     * @param content 待获取回复的内容
     * @param start 一个回复的开始分隔字符串
     * @param end 一个回复的结束分隔字符串
     * @param includeStartEnd 是否包括start和end结束符
     * @return
     */
    public static List<String> getListFromStart2End(String content, String start, String end, boolean includeStartEnd) {
        List<String> list = new ArrayList<String>();
        if (content.indexOf(start) < 0) {
            return list;
        }
        int index_start = -1;
        while ((index_start = content.indexOf(start)) >= 0) {
            content = content.substring(index_start);
            int index_end = content.indexOf(end);
            if (index_end > 0 && index_end > index_start) {
                String subStr = StringUtil.subString(content, start, end);
                if (subStr != null && subStr.length() > 0) {
                    if (includeStartEnd) {
                        list.add(start + subStr + end);
                    } else {
                        list.add(subStr);
                    }

                }
                content = content.substring(content.indexOf(end) + end.length());
            } else {
                break;
            }
        }
        return list;
    }

    /**
     * 从原始字符串中，取得从start字符串开始但不包括start字符串，到end字符串为止其中所有的字符，如str='aabbccddee',start='bb',end='ee',则此时结果为'ccdd'。
     * 开始及结束字符串必须存在，否则就报错。
     * 
     * @param src 源字符串
     * @param start 开始字符串
     * @param end 结尾字符串
     * @return 开始字符串到结尾字符串的中间字符串
     * @throws Exception
     */
    public static String subString(String src, String start, String end) {
        src = src.substring(src.indexOf(start)).substring(start.length());
        if (end != null) {
            src = src.substring(0, src.indexOf(end));
        }
        return src;
    }
    public static boolean isInteger(String str) {  
    	Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");  
    	return pattern.matcher(str).matches();  
    }
}
